Implicit Parallelism in a Functional Subset of Scala

In this paper, we describe our approach to implicitly parallelizing programs written in a functional subset of Scala characterized by the single assignment rule. Our functional programming model is supported by a functional subset of Scala based on our past experiences with the Sisal language and the functional language level of DrJava. We automatically parallelize functional Scala programs by inserting futures and accumulators. We avoid the resource limitations that arise when tasks block on futures by executing delimited continuations on a cooperative scheduler with a fixed number of worker threads. The functional structure of programs written in our Scala subset ensures deadlock freedom since such programs cannot generate cyclic dependences among expressions/futures. Our functional programming model exposes abundant opportunities for safe implicit fine-grain parallelism at the expression level. Such expressions can be represented as future constructs that compute the value of the expression in parallel with the rest of the computation. On the other hand, introducing parallelism adds overhead to manage and schedule execution of the futures and to avoid blocking worker threads when the results of the future are required due to data dependence constraints. To achieve high performance in executing such applications on many-core processors, we must partition the computation into largely independent tasks (contrained by data dependence) with appropriate granularity that is neither too fine nor too coarse and we must must efficiently implement the representation and execution of futures. We currently rely on hand-written code and runtime techniques to determine the appropriate granularity for parallel tasks and we use delimited continuations to represent computations waiting on futures without blocking worker threads. [Copyright notice will appear here once ’preprint’ option is removed.]